home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / MacPNG Library 1.02 / pngMacSrc 1.02 / PNG Library 0.80 / PNGRCB.C < prev    next >
Text File  |  1996-05-29  |  5KB  |  238 lines
  1. /* pngrcb.c - callbacks while reading a png file
  2.  
  3.    libpng 1.0 beta 2 - version 0.8
  4.    For conditions of distribution and use, see copyright notice in png.h
  5.    Copyright (c) 1995 Guy Eric Schalnat, Group 42, Inc.
  6.    August 20, 1995
  7.    */
  8.  
  9. #define PNG_INTERNAL
  10. #include "png.h"
  11.  
  12. void
  13. png_read_IHDR(png_struct *png_ptr, png_info *info,
  14.    png_uint_32 width, png_uint_32 height, int bit_depth,
  15.    int color_type, int compression_type, int filter_type,
  16.    int interlace_type)
  17. {
  18.    if (!png_ptr || !info)
  19.       return;
  20.  
  21.    info->width = width;
  22.    info->height = height;
  23.    info->bit_depth = bit_depth;
  24.    info->color_type = color_type;
  25.    info->compression_type = compression_type;
  26.    info->filter_type = filter_type;
  27.    info->interlace_type = interlace_type;
  28.    if (info->color_type == PNG_COLOR_TYPE_PALETTE)
  29.       info->channels = 1;
  30.    else if (info->color_type & PNG_COLOR_MASK_COLOR)
  31.       info->channels = 3;
  32.    else
  33.       info->channels = 1;
  34.    if (info->color_type & PNG_COLOR_MASK_ALPHA)
  35.       info->channels++;
  36.    info->pixel_depth = info->channels * info->bit_depth;
  37.    info->rowbytes = ((info->width * info->pixel_depth + 7) >> 3);
  38. }
  39.  
  40. void
  41. png_read_PLTE(png_struct *png_ptr, png_info *info,
  42.    png_color *palette, int num)
  43. {
  44.    if (!png_ptr || !info)
  45.       return;
  46.  
  47.    info->palette = palette;
  48.    info->num_palette = num;
  49.    info->valid |= PNG_INFO_PLTE;
  50. }
  51.  
  52. #if defined(PNG_READ_gAMA_SUPPORTED)
  53. void
  54. png_read_gAMA(png_struct *png_ptr, png_info *info, float gamma)
  55. {
  56.    if (!png_ptr || !info)
  57.       return;
  58.  
  59.    info->gamma = gamma;
  60.    info->valid |= PNG_INFO_gAMA;
  61. }
  62. #endif
  63.  
  64. #if defined(PNG_READ_sBIT_SUPPORTED)
  65. void
  66. png_read_sBIT(png_struct *png_ptr, png_info *info,
  67.    png_color_8 *sig_bit)
  68. {
  69.    if (!png_ptr || !info)
  70.       return;
  71.  
  72.    memcpy(&(info->sig_bit), sig_bit, sizeof (png_color_8));
  73.    info->valid |= PNG_INFO_sBIT;
  74. }
  75. #endif
  76.  
  77. #if defined(PNG_READ_cHRM_SUPPORTED)
  78. void
  79. png_read_cHRM(png_struct *png_ptr, png_info *info,
  80.    float white_x, float white_y, float red_x, float red_y,
  81.    float green_x, float green_y, float blue_x, float blue_y)
  82. {
  83.    if (!png_ptr || !info)
  84.       return;
  85.  
  86.    info->x_white = white_x;
  87.    info->y_white = white_y;
  88.    info->x_red = red_x;
  89.    info->y_red = red_y;
  90.    info->x_green = green_x;
  91.    info->y_green = green_y;
  92.    info->x_blue = blue_x;
  93.    info->y_blue = blue_y;
  94.    info->valid |= PNG_INFO_cHRM;
  95. }
  96. #endif
  97.  
  98. #if defined(PNG_READ_tRNS_SUPPORTED)
  99. void
  100. png_read_tRNS(png_struct *png_ptr, png_info *info,
  101.    png_byte *trans, int num_trans,   png_color_16 *trans_values)
  102. {
  103.    if (!png_ptr || !info)
  104.       return;
  105.  
  106.    if (trans)
  107.    {
  108.       info->trans = trans;
  109.    }
  110.    else
  111.    {
  112.       memcpy(&(info->trans_values), trans_values,
  113.          sizeof(png_color_16));
  114.    }
  115.    info->num_trans = num_trans;
  116.    info->valid |= PNG_INFO_tRNS;
  117. }
  118. #endif
  119.  
  120. #if defined(PNG_READ_bKGD_SUPPORTED)
  121. void
  122. png_read_bKGD(png_struct *png_ptr, png_info *info,
  123.    png_color_16 *background)
  124. {
  125.    if (!png_ptr || !info)
  126.       return;
  127.  
  128.    memcpy(&(info->background), background, sizeof(png_color_16));
  129.    info->valid |= PNG_INFO_bKGD;
  130. }
  131. #endif
  132.  
  133. #if defined(PNG_READ_hIST_SUPPORTED)
  134. void
  135. png_read_hIST(png_struct *png_ptr, png_info *info, png_uint_16 *hist)
  136. {
  137.    if (!png_ptr || !info)
  138.       return;
  139.  
  140.    info->hist = hist;
  141.    info->valid |= PNG_INFO_hIST;
  142. }
  143. #endif
  144.  
  145. #if defined(PNG_READ_pHYs_SUPPORTED)
  146. void
  147. png_read_pHYs(png_struct *png_ptr, png_info *info,
  148.    png_uint_32 res_x, png_uint_32 res_y, int unit_type)
  149. {
  150.    if (!png_ptr || !info)
  151.       return;
  152.  
  153.    info->x_pixels_per_unit = res_x;
  154.    info->y_pixels_per_unit = res_y;
  155.    info->phys_unit_type = unit_type;
  156.    info->valid |= PNG_INFO_pHYs;
  157. }
  158. #endif
  159.  
  160. #if defined(PNG_READ_oFFs_SUPPORTED)
  161. void
  162. png_read_oFFs(png_struct *png_ptr, png_info *info,
  163.    png_uint_32 offset_x, png_uint_32 offset_y, int unit_type)
  164. {
  165.    if (!png_ptr || !info)
  166.       return;
  167.  
  168.    info->x_offset = offset_x;
  169.    info->y_offset = offset_y;
  170.    info->offset_unit_type = unit_type;
  171.    info->valid |= PNG_INFO_oFFs;
  172. }
  173. #endif
  174.  
  175. #if defined(PNG_READ_tIME_SUPPORTED)
  176. void
  177. png_read_tIME(png_struct *png_ptr, png_info *info,
  178.    png_time *mod_time)
  179. {
  180.    if (!png_ptr || !info)
  181.       return;
  182.  
  183.    memcpy(&(info->mod_time), mod_time, sizeof (png_time));
  184.    info->valid |= PNG_INFO_tIME;
  185. }
  186. #endif
  187.  
  188. #if defined(PNG_READ_zTXt_SUPPORTED)
  189. void
  190. png_read_zTXt(png_struct *png_ptr, png_info *info,
  191.    char *key, char *text, png_uint_32 text_len, int compression)
  192. {
  193.    if (!png_ptr || !info)
  194.       return;
  195.  
  196.    if (info->max_text <= info->num_text)
  197.    {
  198.       if (info->text)
  199.       {
  200.          png_uint_32 old_max;
  201.  
  202.          old_max = info->max_text;
  203.          info->max_text = info->num_text + 16;
  204.          info->text = (png_text *)png_realloc(png_ptr,
  205.             info->text,
  206.             info->max_text * sizeof (png_text),
  207.             old_max * sizeof (png_text));
  208.       }
  209.       else
  210.       {
  211.          info->max_text = info->num_text + 16;
  212.          info->text = (png_text *)png_malloc(png_ptr,
  213.             info->max_text * sizeof (png_text));
  214.          info->num_text = 0;
  215.       }
  216.    }
  217.  
  218.    info->text[info->num_text].key = key;
  219.    info->text[info->num_text].text = text;
  220.    info->text[info->num_text].text_length = text_len;
  221.    info->text[info->num_text].compression = compression;
  222.    info->num_text++;
  223. }
  224. #endif
  225.  
  226. #if defined(PNG_READ_tEXt_SUPPORTED)
  227. void
  228. png_read_tEXt(png_struct *png_ptr, png_info *info,
  229.    char *key, char *text, png_uint_32 text_len)
  230. {
  231.    if (!png_ptr || !info)
  232.       return;
  233.  
  234.    png_read_zTXt(png_ptr, info, key, text, text_len, -1);
  235. }
  236. #endif
  237.  
  238.